home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / Box2D / Collision / _lx230.as < prev    next >
Encoding:
Text File  |  2010-05-14  |  29.2 KB  |  869 lines
  1. package Box2D.Collision
  2. {
  3.    import Box2D.Common.Math._ui293;
  4.    import Box2D.Common.Math.b2Vec2;
  5.    import Box2D.Common._kc225;
  6.    
  7.    public class _lx230
  8.    {
  9.       public static var s_validate:Boolean = false;
  10.       
  11.       public static const b2_invalid:uint = _kc225.USHRT_MAX;
  12.       
  13.       public static const b2_nullEdge:uint = _kc225.USHRT_MAX;
  14.       
  15.       public var m_worldAABB:_pv475;
  16.       
  17.       public var m_freeProxy:uint;
  18.       
  19.       public var m_quantizationFactor:b2Vec2;
  20.       
  21.       public var m_bounds:Array;
  22.       
  23.       public var m_proxyPool:Array;
  24.       
  25.       public var m_queryResultCount:int;
  26.       
  27.       public var m_pairManager:_xl574;
  28.       
  29.       public var m_timeStamp:uint;
  30.       
  31.       public var m_proxyCount:int;
  32.       
  33.       public var m_queryResults:Array;
  34.       
  35.       public function _lx230(param1:_pv475, param2:_lv495)
  36.       {
  37.          var _loc3_:int = 0;
  38.          var _loc4_:Number = NaN;
  39.          var _loc5_:Number = NaN;
  40.          var _loc6_:_cm170 = null;
  41.          var _loc7_:int = 0;
  42.          m_pairManager = new _xl574();
  43.          m_proxyPool = new Array(_kc225.b2_maxPairs);
  44.          m_bounds = new Array(2 * _kc225.b2_maxProxies);
  45.          m_queryResults = new Array(_kc225.b2_maxProxies);
  46.          m_quantizationFactor = new b2Vec2();
  47.          super();
  48.          m_pairManager._cp216(this,param2);
  49.          m_worldAABB = param1;
  50.          m_proxyCount = 0;
  51.          _loc3_ = 0;
  52.          while(_loc3_ < _kc225.b2_maxProxies)
  53.          {
  54.             m_queryResults[_loc3_] = 0;
  55.             _loc3_++;
  56.          }
  57.          m_bounds = new Array(2);
  58.          _loc3_ = 0;
  59.          while(_loc3_ < 2)
  60.          {
  61.             m_bounds[_loc3_] = new Array(2 * _kc225.b2_maxProxies);
  62.             _loc7_ = 0;
  63.             while(_loc7_ < 2 * _kc225.b2_maxProxies)
  64.             {
  65.                m_bounds[_loc3_][_loc7_] = new _la456();
  66.                _loc7_++;
  67.             }
  68.             _loc3_++;
  69.          }
  70.          _loc4_ = param1.upperBound.x - param1.lowerBound.x;
  71.          _loc5_ = param1.upperBound.y - param1.lowerBound.y;
  72.          m_quantizationFactor.x = _kc225.USHRT_MAX / _loc4_;
  73.          m_quantizationFactor.y = _kc225.USHRT_MAX / _loc5_;
  74.          _loc3_ = 0;
  75.          while(_loc3_ < _kc225.b2_maxProxies - 1)
  76.          {
  77.             _loc6_ = new _cm170();
  78.             m_proxyPool[_loc3_] = _loc6_;
  79.             _loc6_._eu820(_loc3_ + 1);
  80.             _loc6_.timeStamp = 0;
  81.             _loc6_.overlapCount = b2_invalid;
  82.             _loc6_.userData = null;
  83.             _loc3_++;
  84.          }
  85.          _loc6_ = new _cm170();
  86.          m_proxyPool[int(_kc225.b2_maxProxies - 1)] = _loc6_;
  87.          _loc6_._eu820(_yl661.b2_nullProxy);
  88.          _loc6_.timeStamp = 0;
  89.          _loc6_.overlapCount = b2_invalid;
  90.          _loc6_.userData = null;
  91.          m_freeProxy = 0;
  92.          m_timeStamp = 1;
  93.          m_queryResultCount = 0;
  94.       }
  95.       
  96.       public static function _uh90(param1:Array, param2:int, param3:uint) : uint
  97.       {
  98.          var _loc4_:int = 0;
  99.          var _loc5_:int = 0;
  100.          var _loc6_:int = 0;
  101.          var _loc7_:_la456 = null;
  102.          _loc4_ = 0;
  103.          _loc5_ = param2 - 1;
  104.          while(_loc4_ <= _loc5_)
  105.          {
  106.             _loc6_ = (_loc4_ + _loc5_) / 2;
  107.             _loc7_ = param1[_loc6_];
  108.             if(_loc7_.value > param3)
  109.             {
  110.                _loc5_ = _loc6_ - 1;
  111.             }
  112.             else
  113.             {
  114.                if(_loc7_.value >= param3)
  115.                {
  116.                   return uint(_loc6_);
  117.                }
  118.                _loc4_ = _loc6_ + 1;
  119.             }
  120.          }
  121.          return uint(_loc4_);
  122.       }
  123.       
  124.       private function _nk58(param1:Array, param2:Array, param3:_pv475) : void
  125.       {
  126.          var _loc4_:Number = NaN;
  127.          var _loc5_:Number = NaN;
  128.          var _loc6_:Number = NaN;
  129.          var _loc7_:Number = NaN;
  130.          _loc4_ = param3.lowerBound.x;
  131.          _loc5_ = param3.lowerBound.y;
  132.          _loc4_ = _ui293._ct557(_loc4_,m_worldAABB.upperBound.x);
  133.          _loc5_ = _ui293._ct557(_loc5_,m_worldAABB.upperBound.y);
  134.          _loc4_ = _ui293._bk45(_loc4_,m_worldAABB.lowerBound.x);
  135.          _loc5_ = _ui293._bk45(_loc5_,m_worldAABB.lowerBound.y);
  136.          _loc6_ = param3.upperBound.x;
  137.          _loc7_ = param3.upperBound.y;
  138.          _loc6_ = _ui293._ct557(_loc6_,m_worldAABB.upperBound.x);
  139.          _loc7_ = _ui293._ct557(_loc7_,m_worldAABB.upperBound.y);
  140.          _loc6_ = _ui293._bk45(_loc6_,m_worldAABB.lowerBound.x);
  141.          _loc7_ = _ui293._bk45(_loc7_,m_worldAABB.lowerBound.y);
  142.          param1[0] = uint(m_quantizationFactor.x * (_loc4_ - m_worldAABB.lowerBound.x)) & _kc225.USHRT_MAX - 1;
  143.          param2[0] = uint(m_quantizationFactor.x * (_loc6_ - m_worldAABB.lowerBound.x)) & 0xFFFF | 1;
  144.          param1[1] = uint(m_quantizationFactor.y * (_loc5_ - m_worldAABB.lowerBound.y)) & _kc225.USHRT_MAX - 1;
  145.          param2[1] = uint(m_quantizationFactor.y * (_loc7_ - m_worldAABB.lowerBound.y)) & 0xFFFF | 1;
  146.       }
  147.       
  148.       public function _br217(param1:_pv475, param2:*) : uint
  149.       {
  150.          var _loc3_:uint = 0;
  151.          var _loc4_:_cm170 = null;
  152.          var _loc5_:uint = 0;
  153.          var _loc6_:uint = 0;
  154.          var _loc7_:Array = null;
  155.          var _loc8_:Array = null;
  156.          var _loc9_:int = 0;
  157.          var _loc10_:int = 0;
  158.          var _loc11_:Array = null;
  159.          var _loc12_:uint = 0;
  160.          var _loc13_:uint = 0;
  161.          var _loc14_:Array = null;
  162.          var _loc15_:Array = null;
  163.          var _loc16_:Array = null;
  164.          var _loc17_:int = 0;
  165.          var _loc18_:int = 0;
  166.          var _loc19_:_la456 = null;
  167.          var _loc20_:_la456 = null;
  168.          var _loc21_:_la456 = null;
  169.          var _loc22_:int = 0;
  170.          var _loc23_:_cm170 = null;
  171.          _loc5_ = m_freeProxy;
  172.          _loc4_ = m_proxyPool[_loc5_];
  173.          m_freeProxy = _loc4_._ix313();
  174.          _loc4_.overlapCount = 0;
  175.          _loc4_.userData = param2;
  176.          _loc6_ = uint(2 * m_proxyCount);
  177.          _loc7_ = new Array();
  178.          _loc8_ = new Array();
  179.          _nk58(_loc7_,_loc8_,param1);
  180.          _loc9_ = 0;
  181.          while(_loc9_ < 2)
  182.          {
  183.             _loc11_ = m_bounds[_loc9_];
  184.             _loc14_ = [_loc12_];
  185.             _loc15_ = [_loc13_];
  186.             _qr65(_loc14_,_loc15_,_loc7_[_loc9_],_loc8_[_loc9_],_loc11_,_loc6_,_loc9_);
  187.             _loc12_ = uint(_loc14_[0]);
  188.             _loc13_ = uint(_loc15_[0]);
  189.             _loc16_ = new Array();
  190.             _loc18_ = _loc6_ - _loc13_;
  191.             _loc17_ = 0;
  192.             while(_loc17_ < _loc18_)
  193.             {
  194.                _loc16_[_loc17_] = new _la456();
  195.                _loc19_ = _loc16_[_loc17_];
  196.                _loc20_ = _loc11_[int(_loc13_ + _loc17_)];
  197.                _loc19_.value = _loc20_.value;
  198.                _loc19_.proxyId = _loc20_.proxyId;
  199.                _loc19_.stabbingCount = _loc20_.stabbingCount;
  200.                _loc17_++;
  201.             }
  202.             _loc18_ = int(_loc16_.length);
  203.             _loc22_ = _loc13_ + 2;
  204.             _loc17_ = 0;
  205.             while(_loc17_ < _loc18_)
  206.             {
  207.                _loc20_ = _loc16_[_loc17_];
  208.                _loc19_ = _loc11_[int(_loc22_ + _loc17_)];
  209.                _loc19_.value = _loc20_.value;
  210.                _loc19_.proxyId = _loc20_.proxyId;
  211.                _loc19_.stabbingCount = _loc20_.stabbingCount;
  212.                _loc17_++;
  213.             }
  214.             _loc16_ = new Array();
  215.             _loc18_ = _loc13_ - _loc12_;
  216.             _loc17_ = 0;
  217.             while(_loc17_ < _loc18_)
  218.             {
  219.                _loc16_[_loc17_] = new _la456();
  220.                _loc19_ = _loc16_[_loc17_];
  221.                _loc20_ = _loc11_[int(_loc12_ + _loc17_)];
  222.                _loc19_.value = _loc20_.value;
  223.                _loc19_.proxyId = _loc20_.proxyId;
  224.                _loc19_.stabbingCount = _loc20_.stabbingCount;
  225.                _loc17_++;
  226.             }
  227.             _loc18_ = int(_loc16_.length);
  228.             _loc22_ = _loc12_ + 1;
  229.             _loc17_ = 0;
  230.             while(_loc17_ < _loc18_)
  231.             {
  232.                _loc20_ = _loc16_[_loc17_];
  233.                _loc19_ = _loc11_[int(_loc22_ + _loc17_)];
  234.                _loc19_.value = _loc20_.value;
  235.                _loc19_.proxyId = _loc20_.proxyId;
  236.                _loc19_.stabbingCount = _loc20_.stabbingCount;
  237.                _loc17_++;
  238.             }
  239.             _loc13_++;
  240.             _loc19_ = _loc11_[_loc12_];
  241.             _loc20_ = _loc11_[_loc13_];
  242.             _loc19_.value = _loc7_[_loc9_];
  243.             _loc19_.proxyId = _loc5_;
  244.             _loc20_.value = _loc8_[_loc9_];
  245.             _loc20_.proxyId = _loc5_;
  246.             _loc21_ = _loc11_[int(_loc12_ - 1)];
  247.             _loc19_.stabbingCount = _loc12_ == 0 ? 0 : _loc21_.stabbingCount;
  248.             _loc21_ = _loc11_[int(_loc13_ - 1)];
  249.             _loc20_.stabbingCount = _loc21_.stabbingCount;
  250.             _loc3_ = _loc12_;
  251.             while(_loc3_ < _loc13_)
  252.             {
  253.                _loc21_ = _loc11_[_loc3_];
  254.                ++_loc21_.stabbingCount;
  255.                _loc3_++;
  256.             }
  257.             _loc3_ = _loc12_;
  258.             while(_loc3_ < _loc6_ + 2)
  259.             {
  260.                _loc19_ = _loc11_[_loc3_];
  261.                _loc23_ = m_proxyPool[_loc19_.proxyId];
  262.                if(_loc19_._dt130())
  263.                {
  264.                   _loc23_.lowerBounds[_loc9_] = _loc3_;
  265.                }
  266.                else
  267.                {
  268.                   _loc23_.upperBounds[_loc9_] = _loc3_;
  269.                }
  270.                _loc3_++;
  271.             }
  272.             _loc9_++;
  273.          }
  274.          ++m_proxyCount;
  275.          _loc10_ = 0;
  276.          while(_loc10_ < m_queryResultCount)
  277.          {
  278.             m_pairManager._xt32(_loc5_,m_queryResults[_loc10_]);
  279.             _loc10_++;
  280.          }
  281.          m_pairManager._ol779();
  282.          m_queryResultCount = 0;
  283.          _sk25();
  284.          return _loc5_;
  285.       }
  286.       
  287.       private function _dt611(param1:_cm170, param2:_cm170) : Boolean
  288.       {
  289.          var _loc3_:int = 0;
  290.          var _loc4_:Array = null;
  291.          var _loc5_:_la456 = null;
  292.          var _loc6_:_la456 = null;
  293.          _loc3_ = 0;
  294.          while(_loc3_ < 2)
  295.          {
  296.             _loc4_ = m_bounds[_loc3_];
  297.             _loc5_ = _loc4_[param1.lowerBounds[_loc3_]];
  298.             _loc6_ = _loc4_[param2.upperBounds[_loc3_]];
  299.             if(_loc5_.value > _loc6_.value)
  300.             {
  301.                return false;
  302.             }
  303.             _loc5_ = _loc4_[param1.upperBounds[_loc3_]];
  304.             _loc6_ = _loc4_[param2.lowerBounds[_loc3_]];
  305.             if(_loc5_.value < _loc6_.value)
  306.             {
  307.                return false;
  308.             }
  309.             _loc3_++;
  310.          }
  311.          return true;
  312.       }
  313.       
  314.       public function _wp50(param1:uint) : void
  315.       {
  316.          var _loc2_:_la456 = null;
  317.          var _loc3_:_la456 = null;
  318.          var _loc4_:_cm170 = null;
  319.          var _loc5_:int = 0;
  320.          var _loc6_:int = 0;
  321.          var _loc7_:int = 0;
  322.          var _loc8_:Array = null;
  323.          var _loc9_:uint = 0;
  324.          var _loc10_:uint = 0;
  325.          var _loc11_:uint = 0;
  326.          var _loc12_:uint = 0;
  327.          var _loc13_:Array = null;
  328.          var _loc14_:int = 0;
  329.          var _loc15_:int = 0;
  330.          var _loc16_:int = 0;
  331.          var _loc17_:uint = 0;
  332.          var _loc18_:int = 0;
  333.          var _loc19_:_cm170 = null;
  334.          _loc4_ = m_proxyPool[param1];
  335.          _loc5_ = 2 * m_proxyCount;
  336.          _loc6_ = 0;
  337.          while(_loc6_ < 2)
  338.          {
  339.             _loc8_ = m_bounds[_loc6_];
  340.             _loc9_ = uint(_loc4_.lowerBounds[_loc6_]);
  341.             _loc10_ = uint(_loc4_.upperBounds[_loc6_]);
  342.             _loc2_ = _loc8_[_loc9_];
  343.             _loc11_ = _loc2_.value;
  344.             _loc3_ = _loc8_[_loc10_];
  345.             _loc12_ = _loc3_.value;
  346.             _loc13_ = new Array();
  347.             _loc15_ = _loc10_ - _loc9_ - 1;
  348.             _loc14_ = 0;
  349.             while(_loc14_ < _loc15_)
  350.             {
  351.                _loc13_[_loc14_] = new _la456();
  352.                _loc2_ = _loc13_[_loc14_];
  353.                _loc3_ = _loc8_[int(_loc9_ + 1 + _loc14_)];
  354.                _loc2_.value = _loc3_.value;
  355.                _loc2_.proxyId = _loc3_.proxyId;
  356.                _loc2_.stabbingCount = _loc3_.stabbingCount;
  357.                _loc14_++;
  358.             }
  359.             _loc15_ = int(_loc13_.length);
  360.             _loc16_ = int(_loc9_);
  361.             _loc14_ = 0;
  362.             while(_loc14_ < _loc15_)
  363.             {
  364.                _loc3_ = _loc13_[_loc14_];
  365.                _loc2_ = _loc8_[int(_loc16_ + _loc14_)];
  366.                _loc2_.value = _loc3_.value;
  367.                _loc2_.proxyId = _loc3_.proxyId;
  368.                _loc2_.stabbingCount = _loc3_.stabbingCount;
  369.                _loc14_++;
  370.             }
  371.             _loc13_ = new Array();
  372.             _loc15_ = _loc5_ - _loc10_ - 1;
  373.             _loc14_ = 0;
  374.             while(_loc14_ < _loc15_)
  375.             {
  376.                _loc13_[_loc14_] = new _la456();
  377.                _loc2_ = _loc13_[_loc14_];
  378.                _loc3_ = _loc8_[int(_loc10_ + 1 + _loc14_)];
  379.                _loc2_.value = _loc3_.value;
  380.                _loc2_.proxyId = _loc3_.proxyId;
  381.                _loc2_.stabbingCount = _loc3_.stabbingCount;
  382.                _loc14_++;
  383.             }
  384.             _loc15_ = int(_loc13_.length);
  385.             _loc16_ = int(_loc10_ - 1);
  386.             _loc14_ = 0;
  387.             while(_loc14_ < _loc15_)
  388.             {
  389.                _loc3_ = _loc13_[_loc14_];
  390.                _loc2_ = _loc8_[int(_loc16_ + _loc14_)];
  391.                _loc2_.value = _loc3_.value;
  392.                _loc2_.proxyId = _loc3_.proxyId;
  393.                _loc2_.stabbingCount = _loc3_.stabbingCount;
  394.                _loc14_++;
  395.             }
  396.             _loc15_ = _loc5_ - 2;
  397.             _loc17_ = _loc9_;
  398.             while(_loc17_ < _loc15_)
  399.             {
  400.                _loc2_ = _loc8_[_loc17_];
  401.                _loc19_ = m_proxyPool[_loc2_.proxyId];
  402.                if(_loc2_._dt130())
  403.                {
  404.                   _loc19_.lowerBounds[_loc6_] = _loc17_;
  405.                }
  406.                else
  407.                {
  408.                   _loc19_.upperBounds[_loc6_] = _loc17_;
  409.                }
  410.                _loc17_++;
  411.             }
  412.             _loc15_ = int(_loc10_ - 1);
  413.             _loc18_ = int(_loc9_);
  414.             while(_loc18_ < _loc15_)
  415.             {
  416.                _loc2_ = _loc8_[_loc18_];
  417.                --_loc2_.stabbingCount;
  418.                _loc18_++;
  419.             }
  420.             _qr65([0],[0],_loc11_,_loc12_,_loc8_,_loc5_ - 2,_loc6_);
  421.             _loc6_++;
  422.          }
  423.          _loc7_ = 0;
  424.          while(_loc7_ < m_queryResultCount)
  425.          {
  426.             m_pairManager._ch476(param1,m_queryResults[_loc7_]);
  427.             _loc7_++;
  428.          }
  429.          m_pairManager._ol779();
  430.          m_queryResultCount = 0;
  431.          _sk25();
  432.          _loc4_.userData = null;
  433.          _loc4_.overlapCount = b2_invalid;
  434.          _loc4_.lowerBounds[0] = b2_invalid;
  435.          _loc4_.lowerBounds[1] = b2_invalid;
  436.          _loc4_.upperBounds[0] = b2_invalid;
  437.          _loc4_.upperBounds[1] = b2_invalid;
  438.          _loc4_._eu820(m_freeProxy);
  439.          m_freeProxy = param1;
  440.          --m_proxyCount;
  441.       }
  442.       
  443.       private function _mm801(param1:uint) : void
  444.       {
  445.          var _loc2_:_cm170 = null;
  446.          _loc2_ = m_proxyPool[param1];
  447.          if(_loc2_.timeStamp < m_timeStamp)
  448.          {
  449.             _loc2_.timeStamp = m_timeStamp;
  450.             _loc2_.overlapCount = 1;
  451.          }
  452.          else
  453.          {
  454.             _loc2_.overlapCount = 2;
  455.             m_queryResults[m_queryResultCount] = param1;
  456.             ++m_queryResultCount;
  457.          }
  458.       }
  459.       
  460.       public function _ol779() : void
  461.       {
  462.          m_pairManager._ol779();
  463.       }
  464.       
  465.       public function _hu370(param1:int) : _cm170
  466.       {
  467.          var _loc2_:_cm170 = null;
  468.          _loc2_ = m_proxyPool[param1];
  469.          if(param1 == _yl661.b2_nullProxy || _loc2_._dt39() == false)
  470.          {
  471.             return null;
  472.          }
  473.          return _loc2_;
  474.       }
  475.       
  476.       public function _dq210(param1:uint, param2:_pv475) : void
  477.       {
  478.          var _loc3_:Array = null;
  479.          var _loc4_:* = 0;
  480.          var _loc5_:uint = 0;
  481.          var _loc6_:uint = 0;
  482.          var _loc7_:_la456 = null;
  483.          var _loc8_:_la456 = null;
  484.          var _loc9_:_la456 = null;
  485.          var _loc10_:uint = 0;
  486.          var _loc11_:_cm170 = null;
  487.          var _loc12_:uint = 0;
  488.          var _loc13_:_cm170 = null;
  489.          var _loc14_:_mb68 = null;
  490.          var _loc15_:_mb68 = null;
  491.          var _loc16_:Array = null;
  492.          var _loc17_:uint = 0;
  493.          var _loc18_:uint = 0;
  494.          var _loc19_:uint = 0;
  495.          var _loc20_:uint = 0;
  496.          var _loc21_:int = 0;
  497.          var _loc22_:int = 0;
  498.          var _loc23_:uint = 0;
  499.          var _loc24_:_cm170 = null;
  500.          if(param1 == _yl661.b2_nullProxy || _kc225.b2_maxProxies <= param1)
  501.          {
  502.             return;
  503.          }
  504.          if(param2._dt39() == false)
  505.          {
  506.             return;
  507.          }
  508.          _loc12_ = uint(2 * m_proxyCount);
  509.          _loc13_ = m_proxyPool[param1];
  510.          _loc14_ = new _mb68();
  511.          _nk58(_loc14_.lowerValues,_loc14_.upperValues,param2);
  512.          _loc15_ = new _mb68();
  513.          _loc5_ = 0;
  514.          while(_loc5_ < 2)
  515.          {
  516.             _loc7_ = m_bounds[_loc5_][_loc13_.lowerBounds[_loc5_]];
  517.             _loc15_.lowerValues[_loc5_] = _loc7_.value;
  518.             _loc7_ = m_bounds[_loc5_][_loc13_.upperBounds[_loc5_]];
  519.             _loc15_.upperValues[_loc5_] = _loc7_.value;
  520.             _loc5_++;
  521.          }
  522.          _loc5_ = 0;
  523.          while(_loc5_ < 2)
  524.          {
  525.             _loc16_ = m_bounds[_loc5_];
  526.             _loc17_ = uint(_loc13_.lowerBounds[_loc5_]);
  527.             _loc18_ = uint(_loc13_.upperBounds[_loc5_]);
  528.             _loc19_ = uint(_loc14_.lowerValues[_loc5_]);
  529.             _loc20_ = uint(_loc14_.upperValues[_loc5_]);
  530.             _loc7_ = _loc16_[_loc17_];
  531.             _loc21_ = _loc19_ - _loc7_.value;
  532.             _loc7_.value = _loc19_;
  533.             _loc7_ = _loc16_[_loc18_];
  534.             _loc22_ = _loc20_ - _loc7_.value;
  535.             _loc7_.value = _loc20_;
  536.             if(_loc21_ < 0)
  537.             {
  538.                _loc6_ = _loc17_;
  539.                while(_loc6_ > 0 && _loc19_ < (_loc16_[int(_loc6_ - 1)] as _la456).value)
  540.                {
  541.                   _loc7_ = _loc16_[_loc6_];
  542.                   _loc8_ = _loc16_[int(_loc6_ - 1)];
  543.                   _loc23_ = _loc8_.proxyId;
  544.                   _loc24_ = m_proxyPool[_loc8_.proxyId];
  545.                   ++_loc8_.stabbingCount;
  546.                   if(_loc8_._ra161() == true)
  547.                   {
  548.                      if(_id547(_loc14_,_loc24_))
  549.                      {
  550.                         m_pairManager._xt32(param1,_loc23_);
  551.                      }
  552.                      _loc3_ = _loc24_.upperBounds;
  553.                      _loc4_ = int(_loc3_[_loc5_]);
  554.                      _loc4_ = _loc4_ + 1;
  555.                      _loc3_[_loc5_] = _loc4_;
  556.                      ++_loc7_.stabbingCount;
  557.                   }
  558.                   else
  559.                   {
  560.                      _loc3_ = _loc24_.lowerBounds;
  561.                      _loc4_ = int(_loc3_[_loc5_]);
  562.                      _loc4_ = _loc4_ + 1;
  563.                      _loc3_[_loc5_] = _loc4_;
  564.                      --_loc7_.stabbingCount;
  565.                   }
  566.                   _loc3_ = _loc13_.lowerBounds;
  567.                   _loc4_ = int(_loc3_[_loc5_]);
  568.                   _loc4_ = _loc4_ - 1;
  569.                   _loc3_[_loc5_] = _loc4_;
  570.                   _loc7_._tb364(_loc8_);
  571.                   _loc6_--;
  572.                }
  573.             }
  574.             if(_loc22_ > 0)
  575.             {
  576.                _loc6_ = _loc18_;
  577.                while(_loc6_ < _loc12_ - 1 && (_loc16_[int(_loc6_ + 1)] as _la456).value <= _loc20_)
  578.                {
  579.                   _loc7_ = _loc16_[_loc6_];
  580.                   _loc9_ = _loc16_[int(_loc6_ + 1)];
  581.                   _loc10_ = _loc9_.proxyId;
  582.                   _loc11_ = m_proxyPool[_loc10_];
  583.                   ++_loc9_.stabbingCount;
  584.                   if(_loc9_._dt130() == true)
  585.                   {
  586.                      if(_id547(_loc14_,_loc11_))
  587.                      {
  588.                         m_pairManager._xt32(param1,_loc10_);
  589.                      }
  590.                      _loc3_ = _loc11_.lowerBounds;
  591.                      _loc4_ = int(_loc3_[_loc5_]);
  592.                      _loc4_ = _loc4_ - 1;
  593.                      _loc3_[_loc5_] = _loc4_;
  594.                      ++_loc7_.stabbingCount;
  595.                   }
  596.                   else
  597.                   {
  598.                      _loc3_ = _loc11_.upperBounds;
  599.                      _loc4_ = int(_loc3_[_loc5_]);
  600.                      _loc4_ = _loc4_ - 1;
  601.                      _loc3_[_loc5_] = _loc4_;
  602.                      --_loc7_.stabbingCount;
  603.                   }
  604.                   _loc3_ = _loc13_.upperBounds;
  605.                   _loc4_ = int(_loc3_[_loc5_]);
  606.                   _loc4_ = _loc4_ + 1;
  607.                   _loc3_[_loc5_] = _loc4_;
  608.                   _loc7_._tb364(_loc9_);
  609.                   _loc6_++;
  610.                }
  611.             }
  612.             if(_loc21_ > 0)
  613.             {
  614.                _loc6_ = _loc17_;
  615.                while(_loc6_ < _loc12_ - 1 && (_loc16_[int(_loc6_ + 1)] as _la456).value <= _loc19_)
  616.                {
  617.                   _loc7_ = _loc16_[_loc6_];
  618.                   _loc9_ = _loc16_[int(_loc6_ + 1)];
  619.                   _loc10_ = _loc9_.proxyId;
  620.                   _loc11_ = m_proxyPool[_loc10_];
  621.                   --_loc9_.stabbingCount;
  622.                   if(_loc9_._ra161())
  623.                   {
  624.                      if(_id547(_loc15_,_loc11_))
  625.                      {
  626.                         m_pairManager._ch476(param1,_loc10_);
  627.                      }
  628.                      _loc3_ = _loc11_.upperBounds;
  629.                      _loc4_ = int(_loc3_[_loc5_]);
  630.                      _loc4_ = _loc4_ - 1;
  631.                      _loc3_[_loc5_] = _loc4_;
  632.                      --_loc7_.stabbingCount;
  633.                   }
  634.                   else
  635.                   {
  636.                      _loc3_ = _loc11_.lowerBounds;
  637.                      _loc4_ = int(_loc3_[_loc5_]);
  638.                      _loc4_ = _loc4_ - 1;
  639.                      _loc3_[_loc5_] = _loc4_;
  640.                      ++_loc7_.stabbingCount;
  641.                   }
  642.                   _loc3_ = _loc13_.lowerBounds;
  643.                   _loc4_ = int(_loc3_[_loc5_]);
  644.                   _loc4_ = _loc4_ + 1;
  645.                   _loc3_[_loc5_] = _loc4_;
  646.                   _loc7_._tb364(_loc9_);
  647.                   _loc6_++;
  648.                }
  649.             }
  650.             if(_loc22_ < 0)
  651.             {
  652.                _loc6_ = _loc18_;
  653.                while(_loc6_ > 0 && _loc20_ < (_loc16_[int(_loc6_ - 1)] as _la456).value)
  654.                {
  655.                   _loc7_ = _loc16_[_loc6_];
  656.                   _loc8_ = _loc16_[int(_loc6_ - 1)];
  657.                   _loc23_ = _loc8_.proxyId;
  658.                   _loc24_ = m_proxyPool[_loc23_];
  659.                   --_loc8_.stabbingCount;
  660.                   if(_loc8_._dt130() == true)
  661.                   {
  662.                      if(_id547(_loc15_,_loc24_))
  663.                      {
  664.                         m_pairManager._ch476(param1,_loc23_);
  665.                      }
  666.                      _loc3_ = _loc24_.lowerBounds;
  667.                      _loc4_ = int(_loc3_[_loc5_]);
  668.                      _loc4_ = _loc4_ + 1;
  669.                      _loc3_[_loc5_] = _loc4_;
  670.                      --_loc7_.stabbingCount;
  671.                   }
  672.                   else
  673.                   {
  674.                      _loc3_ = _loc24_.upperBounds;
  675.                      _loc4_ = int(_loc3_[_loc5_]);
  676.                      _loc4_ = _loc4_ + 1;
  677.                      _loc3_[_loc5_] = _loc4_;
  678.                      ++_loc7_.stabbingCount;
  679.                   }
  680.                   _loc3_ = _loc13_.upperBounds;
  681.                   _loc4_ = int(_loc3_[_loc5_]);
  682.                   _loc4_ = _loc4_ - 1;
  683.                   _loc3_[_loc5_] = _loc4_;
  684.                   _loc7_._tb364(_loc8_);
  685.                   _loc6_--;
  686.                }
  687.             }
  688.             _loc5_++;
  689.          }
  690.       }
  691.       
  692.       public function _is157(param1:_pv475) : Boolean
  693.       {
  694.          var _loc2_:Number = NaN;
  695.          var _loc3_:Number = NaN;
  696.          var _loc4_:Number = NaN;
  697.          var _loc5_:Number = NaN;
  698.          _loc2_ = param1.lowerBound.x;
  699.          _loc3_ = param1.lowerBound.y;
  700.          _loc2_ -= m_worldAABB.upperBound.x;
  701.          _loc3_ -= m_worldAABB.upperBound.y;
  702.          _loc4_ = m_worldAABB.lowerBound.x;
  703.          _loc5_ = m_worldAABB.lowerBound.y;
  704.          _loc4_ -= param1.upperBound.x;
  705.          _loc5_ -= param1.upperBound.y;
  706.          _loc2_ = _ui293._bk45(_loc2_,_loc4_);
  707.          _loc3_ = _ui293._bk45(_loc3_,_loc5_);
  708.          return _ui293._bk45(_loc2_,_loc3_) < 0;
  709.       }
  710.       
  711.       public function _yg769(param1:_pv475, param2:*, param3:int) : int
  712.       {
  713.          var _loc4_:Array = null;
  714.          var _loc5_:Array = null;
  715.          var _loc6_:uint = 0;
  716.          var _loc7_:uint = 0;
  717.          var _loc8_:Array = null;
  718.          var _loc9_:Array = null;
  719.          var _loc10_:int = 0;
  720.          var _loc11_:int = 0;
  721.          var _loc12_:_cm170 = null;
  722.          _loc4_ = new Array();
  723.          _loc5_ = new Array();
  724.          _nk58(_loc4_,_loc5_,param1);
  725.          _loc8_ = [_loc6_];
  726.          _loc9_ = [_loc7_];
  727.          _qr65(_loc8_,_loc9_,_loc4_[0],_loc5_[0],m_bounds[0],2 * m_proxyCount,0);
  728.          _qr65(_loc8_,_loc9_,_loc4_[1],_loc5_[1],m_bounds[1],2 * m_proxyCount,1);
  729.          _loc10_ = 0;
  730.          _loc11_ = 0;
  731.          while(_loc11_ < m_queryResultCount && _loc10_ < param3)
  732.          {
  733.             _loc12_ = m_proxyPool[m_queryResults[_loc11_]];
  734.             param2[_loc11_] = _loc12_.userData;
  735.             _loc11_++;
  736.             _loc10_++;
  737.          }
  738.          m_queryResultCount = 0;
  739.          _sk25();
  740.          return _loc10_;
  741.       }
  742.       
  743.       public function _ej487() : void
  744.       {
  745.          var _loc1_:_yl661 = null;
  746.          var _loc2_:_cm170 = null;
  747.          var _loc3_:_cm170 = null;
  748.          var _loc4_:Boolean = false;
  749.          var _loc5_:int = 0;
  750.          var _loc6_:_la456 = null;
  751.          var _loc7_:uint = 0;
  752.          var _loc8_:uint = 0;
  753.          var _loc9_:uint = 0;
  754.          var _loc10_:_la456 = null;
  755.          _loc5_ = 0;
  756.          while(_loc5_ < 2)
  757.          {
  758.             _loc6_ = m_bounds[_loc5_];
  759.             _loc7_ = uint(2 * m_proxyCount);
  760.             _loc8_ = 0;
  761.             _loc9_ = 0;
  762.             while(_loc9_ < _loc7_)
  763.             {
  764.                _loc10_ = _loc6_[_loc9_];
  765.                if(_loc10_._dt130() == true)
  766.                {
  767.                   _loc8_++;
  768.                }
  769.                else
  770.                {
  771.                   _loc8_--;
  772.                }
  773.                _loc9_++;
  774.             }
  775.             _loc5_++;
  776.          }
  777.       }
  778.       
  779.       private function _sk25() : void
  780.       {
  781.          var _loc1_:uint = 0;
  782.          if(m_timeStamp == _kc225.USHRT_MAX)
  783.          {
  784.             _loc1_ = 0;
  785.             while(_loc1_ < _kc225.b2_maxProxies)
  786.             {
  787.                (m_proxyPool[_loc1_] as _cm170).timeStamp = 0;
  788.                _loc1_++;
  789.             }
  790.             m_timeStamp = 1;
  791.          }
  792.          else
  793.          {
  794.             ++m_timeStamp;
  795.          }
  796.       }
  797.       
  798.       public function _id547(param1:_mb68, param2:_cm170) : Boolean
  799.       {
  800.          var _loc3_:int = 0;
  801.          var _loc4_:Array = null;
  802.          var _loc5_:_la456 = null;
  803.          _loc3_ = 0;
  804.          while(_loc3_ < 2)
  805.          {
  806.             _loc4_ = m_bounds[_loc3_];
  807.             _loc5_ = _loc4_[param2.upperBounds[_loc3_]];
  808.             if(param1.lowerValues[_loc3_] > _loc5_.value)
  809.             {
  810.                return false;
  811.             }
  812.             _loc5_ = _loc4_[param2.lowerBounds[_loc3_]];
  813.             if(param1.upperValues[_loc3_] < _loc5_.value)
  814.             {
  815.                return false;
  816.             }
  817.             _loc3_++;
  818.          }
  819.          return true;
  820.       }
  821.       
  822.       private function _qr65(param1:Array, param2:Array, param3:uint, param4:uint, param5:Array, param6:uint, param7:int) : void
  823.       {
  824.          var _loc8_:uint = 0;
  825.          var _loc9_:uint = 0;
  826.          var _loc10_:_la456 = null;
  827.          var _loc11_:uint = 0;
  828.          var _loc12_:int = 0;
  829.          var _loc13_:int = 0;
  830.          var _loc14_:_cm170 = null;
  831.          _loc8_ = _uh90(param5,param6,param3);
  832.          _loc9_ = _uh90(param5,param6,param4);
  833.          _loc11_ = _loc8_;
  834.          while(_loc11_ < _loc9_)
  835.          {
  836.             _loc10_ = param5[_loc11_];
  837.             if(_loc10_._dt130())
  838.             {
  839.                _mm801(_loc10_.proxyId);
  840.             }
  841.             _loc11_++;
  842.          }
  843.          if(_loc8_ > 0)
  844.          {
  845.             _loc12_ = int(_loc8_ - 1);
  846.             _loc10_ = param5[_loc12_];
  847.             _loc13_ = int(_loc10_.stabbingCount);
  848.             while(_loc13_)
  849.             {
  850.                _loc10_ = param5[_loc12_];
  851.                if(_loc10_._dt130())
  852.                {
  853.                   _loc14_ = m_proxyPool[_loc10_.proxyId];
  854.                   if(_loc8_ <= _loc14_.upperBounds[param7])
  855.                   {
  856.                      _mm801(_loc10_.proxyId);
  857.                      _loc13_--;
  858.                   }
  859.                }
  860.                _loc12_--;
  861.             }
  862.          }
  863.          param1[0] = _loc8_;
  864.          param2[0] = _loc9_;
  865.       }
  866.    }
  867. }
  868.  
  869.